import fileinput, time, re

def grep_expression():
  i,a = 0,0
  list = []
  f=file('s.html','r')
  text = f.read()
  list = re.findall('<b>[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]|[0-9+][0-9+][:][0-9+][0-9+]|NON&#160;ASSEGNATO|RIPOSO|DISPONIBILITA|ASSENZA|INTERVALLO|FERIE|CORSO',text)
  while i < len(list):
    a = list[i].find('<b>')
    if a != -1:
      list[i] = list[i][a+3:]
    
    b = list[i].find('&#160;')
    if b != -1:
      list[i] = list[i][0:b] + list[i][b+6:]
    i = i + 1

  return list

def suddividi_dati_servizi(re_list):
  """La funzione riceve una lista contenente dati di turno, identificabili attraverso espressioni regolari, restituisce 
     una lista contenente le lunghezze dei pattern contraddistinti da --> DD/MM/AAAA, 2  REGEXP del tipo [HH:MM] oppure 
     1 REGEXP del tipo [RIPOSO| INTERVALLO| DISPONIBILITA| ASSENZA| NON ASSEGNATO| ecc], quindi DD/MM/AAAA.
     Esempio con la lista di input ['16/09/2012','RIPOSO','17/09/2012','14:22','22:34','18/09/2012','12:37','19:56']
     la funzione restituisce la lista [2,3,3]"""
  count = 0 
  start = 0
  length_list = []
  # Le espressioni iniziano sempre con una data, distinguiamo i casi che e' possibile ritrovare:
  #     -1 se si tratta di una giornata lavorativa AR avremo || giorno, orario inizio , orario fine || LUNGHEZZA 3
  #     -2 se si tratta di una giornata lavorativa RFR avremo || giorno, orario inizio  || per la giornata di andata e 
  #         se si tratta di una giornata lavorativa AR avremo || giorno , orario fine || per la giornata di ritorno. LUNGHEZZA 2 + 2
  #     -3 se si tratta di una giornata non lavorativa mobile si avra' ||giorno, tipo attivita' ||  LUNGHEZZA 2
  #    La strategia utilizzata e' quella di creare una lista delle lunghezze incontrate, utili a distinguere successivamente i 3 casi
  #    elencati.
  for elements in (re_list):
    data =  re.match('[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]', elements)
    if data:
      start = 1
    if not (data) and start == 1:#se ho gia incontrato una data, allora posso contare l'occorrenza 
      count += 1
    if data and count > 0:#siamo in presenza del termine del pezzo di dato a cui siamo interessati
      length_list.append(count+1)
      count = 0
  length_list.append(count+1)
  return length_list


def write_data_in_order(re_list, lista_dati_servizi):
  list = []
  counter = 0
  global_counter = 0
  s = []
  """La funzione si occupa della scrittura delle espressioni di turno ricevute in input, su file, formattando 
     l'output nella forma DD/MM/YYYY| DATI SERVIZIO/ 
     Restituisce 1 in caso di successo, -1 in caso di insuccesso, None se non e' stato scritto nulla nel file."""
  for elements in (lista_dati_servizi):
    while counter < elements:
      s.append(re_list[global_counter])
      counter += 1
      global_counter += 1
     
    list.append(s)
    #global_counter += counter
    counter = 0
    s = []
  return list

  
  
#def data_decorator(data_list):
  #""" La funzione si occupa di trasformare i dati di turno aventi una delle forme {DD/MM/AAAA HH:MM} oppure	
      ##{DD/MM/AAAA HH;MM HH:MM} {DD/MM/AAAA tipo servizio} nel formato lunghezza fissa presente nel file turno caratterizzato da:
      ##{tipo servizio}-->[AR,RFR,R,A,D,eccc] | {giorno inizio} | {ora inizio} | {data fine} | {ora fine}  
      ##es. --1 AR,15/9/2012,1318,15/9/2012,2234
	  ##--2 RIPOSO,16/9/2012,100,16/9/2012,2400
	  ##--3 AR,17/9/2012,1422,17/9/2012,2234
	  ##Le regole per l'assegnazione delle ore sono le seguenti:
	  ##--le giornate di riposo o intervallo sono contabilizzate in 24h ossia 
	  ##--le giornate di lavoro hanno una componente A--> dalle 24.00 all-ora di inizio prestazione e una B--> dal termine prestazione 
	    ##alle 0.00
	  ##--le rimanenti giornate non hanno valore assegnato
	  ##L'organizzazione ideata permette un rapida valutazione di quanto ogni giornata concorre al riposo settimanale oppure
	  ##giornaliero, infatti a titolo esplicativo esplicitiamo tale valutazione riferendosi all'esempio precedentemente.
	  ##La giornata 1 ha A--> 13h18m B-->1h26m, giornata 2 ha 24h di riposo, infine la giornata 3 ha A-->14.22 B-->1h26m. 
	  ##Per al valutazione delle ore di riposo dobbiamo sommare B di 1 + riposo di 2 + A di 3, avremo quindi
	  ##che le ore di riposo sono date da 1h26m + 24h + 14h22m = 49h48m.
	  ##Il risultato dell'elaborazione viene accodato all-interno della lista di input, i dati accodati sono nell-ordine di accodamento
	  ##sec_A|sec_B|prest_giorn|riposo, quest-ultimo campo viene valorizzato a 86400 solo per le giornate intere di riposo o intervallo.
	  #La nuova struttura dati impiegata per il trasporto dei dati e' cosi' strutturata:
	  #[|Tipo|Data|ora i|ora f|sec_A|sec_B|prestazione|riposo [prestazione|riposo|RFR] ]"""
  #new_pdf = 0
  #massimo = max(data_list)
  #""" La condizione verifica se siamo in presenza del nuovo tipo di pdf. In questo caso le lunghezze dei dati ritrovati
      #hanno come massimo 5 anziche' 3."""
  #if massimo > 3:
    #new_pdf = 1
  
  #riposo_list = []
  #dati_formattati_tabella = []
  #dati_aggiunti = []
  #sec_A,sec_B, prest_giorn,riposo = 0,0,0,0
  #rfr = 0
  #rfr_count = 0
  #index = 0 
  #for elements in data_list:
    ##cattura pattern data, serve per il caso dei RFR
    #rfr = re.match('[0-9+][0-9+][:][0-9+][0-9+]', elements[1])
    ##print 'elements: %s len: %d \n' % (elements,len(elements))
    ##print "*******************data_decorator***************" ,data_list,'\n'
    ##print elements
    ##Nella nuova versione di pdf e' stata modificata l'organizzazione comprendendo ulteriori informazioni
    ##vedi note successive.
    #if len(elements) == 4 and elements[1] == 'DISPONIBILITA':
      ##Gestione del caso di disponibilita con termine massimo prestazione prestabilito DISPONIBILITA fine: HH:MM
      ##in questo caaso devo calcolare solo sec_B"""
      #ora_temp = ''
      ##non e' possibile atttualmente sapere quale degli ultimi 2 elementi e' l-ora di termine prestazione programmato.
      ##ora_temp = elements.pop()
      #elements.append('00:00')
      #elements.append(ora_temp)
      #orario = 0
      #riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
      #giorno, mese, anno = spezza_data(elements[0])
      #ora,minuti = elements[3][:2] , elements[3][3:]
      #orario = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora),s_to_int(minuti) )
      #under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
      #elements.append(sec_A)
      #sec_B = (under_mezzanotte.__sub__(orario)).total_seconds()+1
      #elements.append(sec_B)
      #elements.append(prest_giorn)
      #elements.append(riposo)
      #dati_formattati_tabella.append([elements[0],elements[1],elements[2],ora_temp,prest_giorn])
      ##print elements
      #"""La lunghezza 5 e' unica e coincide con una giornata AR in cui si ha: 
		  #(data, ora inizio, ora termine, prestazione, riposo giornaliero)  """
		  
    #if len(elements) == 5:
	#print 'elements: %s len: %d \n' % (elements,len(elements))
	#giorno, mese, anno = spezza_data(elements[0])
	#ora_i, minuti_i = elements[1][:2] , elements[1][3:]
	##print ora_i,minuti_i,'data hour inizio\n'
	#ora_f,minuti_f = elements[2][:2] , elements[2][3:]
	##print ora_f,minuti_f,'data hour fine\n'
	#inizio = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_i),s_to_int(minuti_i) )
	##print s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_i),s_to_int(minuti_i),'inizio data \n'
	#fine = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora_f),s_to_int(minuti_f) )
	#under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
	#over_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),00,00,00)
	#sec_A = (inizio.__sub__(over_mezzanotte)).total_seconds()
	#sec_B = (under_mezzanotte.__sub__(fine)).total_seconds()+1
	#prest_giorn = fine.__sub__(inizio).total_seconds()
	#riposo = 0 
	#rfr = 0
	
	#dati_formattati_tabella.append([elements[0],'AR',elements[1],elements[2],prest_giorn])
	
	###print 'giorno %s A: %d B: %d prest. giornaliera %d \n'% (elements[0],sec_A,sec_B,prest_giorn)
	###print elements
    #if len(elements) == 2 and elements[1] == 'INTERVALLO':#Giornata di intervallo.
	
	#riposo_list.append(index)
	#riposo_list.append(elements[0])
	#riposo_list.append(elements[1])
	#riposo,sec_A,sec_B,prest_giorn = 86400,0,0,0#l'attributo riposo che conta di 86400 secondi
	#elements.append(sec_A)
	#elements.append(sec_B)
	#elements.append(prest_giorn)
	#elements.append(riposo)
	#rfr = 0 
	#dati_formattati_tabella.append([elements[0],elements[1],'00:00','00:00',prest_giorn])
	##print elements
	
    #if len(elements) == 4 and elements[1] == 'CORSO':
	#riposo,sec_A,sec_B = 0,0,0
	#elements.append(sec_A)
	#elements.append( int(elements[3][:2])*3600 + int(elements[3][-2:])*60 )
	#ore = elements[2][:2]
	#minuti = elements[2][-2:]
	#secondi_prestazione = int(ore)*3600 + int(minuti)*60
	#elements.append(secondi_prestazione)
	#elements.append(riposo)
	#rfr = 0
	#dati_formattati_tabella.append([elements[0],elements[1],'00:00','00:00',secondi_prestazione])
	#dati_aggiunti.append([element[0],element[2],element[3],0])#data,prestazione,riposo,RFR.
	##print elements
	
    #if len(elements) == 4 and rfr and rfr_count == 0:#Inizialmente manca uno dei due orari, verra' impostato uno fittizio 00:00 per mantenere la
				   ##stessa organizzazione dei campi 
	#rfr = elements.pop()
	#prestazione = elements.pop()
	#elements.append('00:00')
	#elements
	#orario = 0
	#rfr_count = 1
	#riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
	#giorno, mese, anno = spezza_data(elements[0])
	#ora,minuti = elements[1][:2] , elements[1][3:]
	#orario = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora),s_to_int(minuti) )
	#over_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),00,00,00)
	#sec_A = (orario.__sub__(over_mezzanotte)).total_seconds()
	#elements.append(sec_A)
	#elements.append(sec_B)
	#elements.append(prest_giorn)
	#elements.append(riposo)
	#rfr = 0
	#dati_formattati_tabella.append([elements[0],'RFR',elements[1],'00:00',prest_giorn])
	##print elements
    ##if len(elements) == 2 and rfr and rfr_count == 1:#se si tratta della giornata di ritorno di un RFR posso calcolare solo sec_B.
	##ora_temp = ''
	##ora_temp = elements.pop()
	##elements.append('00:00')
	##elements.append(ora_temp)
	##orario = 0
	##rfr_count = 0
	##riposo,sec_A,sec_B,prest_giorn = 0,0,0,0
	##giorno, mese, anno = spezza_data(elements[0])
	##ora,minuti = elements[2][:2] , elements[2][3:]
	##orario = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),s_to_int(ora),s_to_int(minuti) )
	##under_mezzanotte = datetime.datetime(s_to_int(anno),s_to_int(mese),s_to_int(giorno),23,59,59)
	##elements.append(sec_A)
	##sec_B = (under_mezzanotte.__sub__(orario)).total_seconds()+1
	##elements.append(sec_B)
	##elements.append(prest_giorn)
	##elements.append(riposo)
	##rfr = 0
	##dati_formattati_tabella.append([elements[0],'RFR','00:00',elements[2],prest_giorn])
	###print elements
    ##index += 1
  ###print riposo_list
  ##print 'data decorator data_list',data_list ,'\n'
  ##print 'data decorator dati_formattati',dati_formattati_tabella, '\n'
  ##return data_list,riposo_list,dati_formattati_tabella
 

data_in = grep_expression()
data_mid = suddividi_dati_servizi(data_in)
data_ordered = write_data_in_order(data_in,data_mid)
print data_mid
print data_ordered
  


#print list




#ESPRESSIONE regolare per la ricerca della data in neretto 
#cat s.html |grep '<b>'[0-9+][0-9+][/][0-9+][0-9+][/][0-9+][0-9+][0-9+][0-9+]
#ricerca dell'ora inizio-termine servizio
# cat s.html |grep [0-9+][0-9+][:][0-9+][0-9+] ricerca ora inizio termine prestazione
# altri tipi di servizio RIPOSO, INTERVALLO, DISPONIBILITA, ASSENZA, NON ASSEGNATO, ecc

